Graphics Benchmarks, Roy Longbottom's PC benchmark Collection

Graphics Benchmarks

Roy Longbottom

General

Windows Drawing Benchmarks

Windows DirectDraw Benchmarks

Windows Direct3D Benchmark

Windows OpenGL Benchmarks

Windows Direct3D9 Benchmarks

Windows BMPSpeed Benchmarks

Windows and Linux JavaDraw Benchmarks

Linux OpenGL Benchmarks

Linux SDL_BMPSpeed Benchmarks

Summary

My first graphics benchmarks were written in the days of dial-up Internet access, to provide a range of performance measurements without the need to download large volumes of image data, starting with DOS in 1997 and progressing via Windows and Linux to present times, with added 64 bit varieties.

Nine separate benchmarks cover Windows drawing, DirectDraw, Direct3D and Direct3D9, then OpenGL 3D and bitmap graphics for Windows and Linux. Direct3D9 can test multiple monitors and many have special options to use for stress testing.

General

My first graphics benchmarks were written in the days of dial-up Internet access, to provide a range of performance measurements without the need to download large volumes of image data. Other ones, with results provided below, were produced by a later compiler as 32 bit and 64 bit versions and run on a PC with a 1994 3.9 GHz Core i7 4820K CPU with a mid range GeForce GTX 650 graphics card, controlled by Windows 10.

The benchmarks run a series of different tests, with few to particularly large demands, that can automatically use full screen operation, with different pixel dimensions, or different sized windows, at default settings. Most display on screen performance details whilst running and all save results in a text based log file. All benchmarks, along with source codes, are include in Windows-Graphics-Benchmarks.zip, to run via Windows, or linux-graphics-benchmarks.tar.gz via Linux.

Windows Drawing Benchmarks - draws different shapes, copies blocks of image data, colours an area, and pokes pixels, with performance measured in Millions of Pixels Per Second and Frames Per Second.

Windows DirectDraw Benchmarks - uses DirectDraw functions to copy image data and to colour fill an area, with performance measured in Millions of Pixels Per Second and Frames Per Second.

Windows Direct3D Benchmark - uses Direct3D functions operating on wireframe, coloured and textured moving objects, with performance measured in Frames Per Second, replaced with Direct3D9 Benchmarks for 32 bit and 64 bit versions.

Windows OpenGL Benchmarks - Coloured and textured moving objects, again, and a complex wireframe and textured real simulation of a kitchen, with performance measured in Frames Per Second.

Windows Direct3D9 Benchmarks - with similar wireframe, coloured and textured objects plus use of Pixel and Vertex Shaders, with performance measured in Frames Per Second.

Windows BMPSpeed Benchmarks - This is system test, with graphics activity, comprising writing and reading small to enlarged images, scrolling and rotating them, with time in seconds and milliseconds plus MB/second for scrolling.

JavaDraw Benchmark - for running via Windows, Lixux and Andrioid, starting with a simple scene with added complexity for subsequent tests, with performance measured in Frames Per Second. There is also an on-line version of this benchmark, executed via a downloaded HTML document.

Linux OpenGL Benchmarks - This is a similar to, but enhanced, version of the Windows OpenGL program. Approval was given to Canonical to include this benchmark in the testing framework for the Unity desktop.

Linux SDL BMPSpeed Benchmarks - carrying out the same functional tests as Windows BMPSpeed, but written using Simple DirectMedia Layer functions.

Stress Testing - The benchmarks have run time parameters to include a number of the benchmarks in a stress testing exercise, including which section to run and running time. See burnin64.htm, burnin4cpu.htm and linux burn-in apps.htm.

Go To Start

Windows Drawing Benchmarks - VideoWin.exe, VideoWin32.exe, VideoWin64.exe

The forerunner of VideoWin was VideoDOS.exe, produced in December 1997. This has parameters to run at resolutions between 640 x 480 to 1024 x 768, at 16 or 256 colours, with six tests measuring performance in millions of pixels per second. An example of results is provided below. The benchmark is available in DOSTests.zip. For anyone wanting to compare performance of older systems, this includes VideoRes.txt, with lots of results for 80386 to Pentium III.

VideoWin Benchmark again measures graphics speeds in terms of millions of pixels per second but for six Windows drawing and screen copying functions. The latest version has two additional tests, drawing 10000 random length/direction lines and 1000 ellipses as a 3D like object. Speed for these is measured in frames per second. The 8 tests are: Results for all Windows graphics benchmarks are included in videowin results.htm, with samples below for 80486 and Core i7 based PCs.

1 - BitBlt copy from system memory
2 - Drawing small Ellipses
3 - Recangle Fill
4 - Setpixel
5 - Drawing short lines
6 - BitBlt copy screen to screen
7 - Drawing 10000 Lines full screen
8 - Drawing 1000 Ellipses full screen

The front end VideoWin driver has tick boxes to select all available pixel sizes at 8, 16, 24 and 32 bits per pixel, with default 640 x 480 to 1024 x 768, using monitor properties settings to run in full screen mode, and whatever bits per pixel settings are available. The back end is OneWin.exe, that can be run separately to use current video settings. VideoWin64 and VideoWin32 only execute the OneWin test procedures. These were produced via later compilers to use 64 bit and 32 bit systems. The benchmarks, along with source codes, are included in Windows-Graphics-Benchmarks.zip.

Windows vs DOS - From the results below, except for Ellipse tests, the equivalent Windows speeds are shown to be much faster, particularly those involved in BitBlt bit-block transfer compared with Get/Put.

VideoWin - Most of the tests, measuring millions of pixels per second, seem rather strange, with increasing performance as the resolution increases. This is because the full screen is used, not a window sized in pixels. On older PCs, performance could be similar with increasing resolution selection. However, converting the speeds to frames per second, as in DirectDraw Benchmarks a more constant speed is indicated.

OneWin and VideoWin32 and 64 - All results are effectively the same for all tests.

Results VideoDOS.EXE 256 COLOURS Genoa 8000 Graphics Put Ell- Rect Set Draw Get/ CPU image ipse fill pixel line Put CPU MHz Size MP/S MP/S MP/S MP/S MP/S MP/S 80386 40 1024x768 1.08 0.31 1.37 0.003 0.20 0.63 80486 66 1024x768 2.11 0.51 2.42 0.004 0.29 0.96 *************************************************************************** VideoWin.exe S3 VLB Graphics BitB Ell- Rect Set Draw BitB 10000 1000 CPU Colours Mem ipse fill pixel line Scrn Lines Ellips CPU MHz Size MP/S MP/S MP/S MP/S MP/S MP/S FPS FPS 486 66 256 1024x768 10 0.08 24 0.014 0.95 25 486 66 16K 1024x768 6 0.07 13 0.014 0.98 11 1.36 0.19 *************************************************************************** VideoWin.exe Core i7 4820K GTX 650 graphics .......... Millions of Pixels Per Second ........... ..Frames/Second.. Resolution BitBlt1 Ellipse Rectfill SetPixel DrawLine BitBlt2 Lines10K Ellips1K 640 480 32 271.87 10.638 911.28 0.208 15.08 722.97 12.79 23.35 800 600 32 495.23 19.013 1700.77 0.212 18.04 1269.47 10.47 15.56 1024 768 32 650.48 26.531 3208.98 0.218 24.59 2295.25 10.49 11.29 1280 1024 32 780.73 43.456 5667.61 0.219 38.27 4072.32 9.54 7.10 1600 1200 32 922.85 55.515 7507.16 0.219 48.26 5908.29 8.43 4.59 *************************************************************************** Various at Resolution 1920 x 1080 32 bits, Core i7 4820K GTX 650 graphics .......... Millions of Pixels Per Second ........... ..Frames/Second.. Benchmark BitBlt1 Ellipse Rectfill SetPixel DrawLine BitBlt2 Lines10K Ellips1K OneWin 976.96 45.398 7444.36 0.215 56.45 6085.82 6.81 4.75 VideoWin32 1001.75 43.818 7445.86 0.208 56.67 6137.75 8.09 4.72 VideoWin64 1004.93 45.135 7348.10 0.224 57.23 6251.74 8.17 4.66

Go To Start

DirectDraw Benchmarks - VideoDD.exe, VideoDD32.exe, VideoDD64.exe

VideoDD Benchmark measures graphics speeds via DirectDraw functions, in terms of millions of pixels per second (MP/S) and frames per second (FPS) using various drawing functions at all available monitor size and colour settings, in full screen mode. The tests are:

1 - DirectDraw BltFast from an off screen surface in video RAM to the screen primary surface - MP/S and FPS.

2 - DirectDraw Blt (with stretch) from an off screen surface in video RAM to the screen primary surface - MP/S.

3 - DirectDraw Blt with COLORFILL to the screen primary surface - MP/S.

4 - As Test 3 but using DirectDraw WaitForVerticalBlank (VSYNCH) to clamp the speed to the screen refresh Hz - MP/S and FPS. The latter identifies the refresh frequency.

5 - DirectDraw BltFast from a large surface in main RAM to the screen primary surface - MP/S and FPS.

DirectDraw.exe has the same front end as VideoWin, to select monitor setting that are changed under monitor properties to run in full screen mode. Similarly, the back end, and later 32 bit and 64 bit compilations, carry out tests at the current settings. Results from 2002 to 2014 are available in directdraw results.htm and below are measurement from a 66 MHz 80486, to demonstrate performance improvements over the years. Further comparisons are included in directdraw results.htm. VSYNCH speeds were not included in that report. The benchmarks, along with source codes, are included in Windows-Graphics-Benchmarks.zip.

As for VideoWin, speed in millions of pixels per second can increase at higher monitor settings, but frames per second, reflecting user observed performance, can be considerably reduced.

Of late, BltFast from an off screen surface in video RAM measurements have been indicated as particularly slow using GeForce graphics cards, when it expected to be faster than BltFast from RAM. Results for a PC with an AMD CPU and a Radeon graphics card are provided to show expected performance.

The other anomaly is that VSYNCH inconsistent speeds can be indicated, when they should be no higher than 60 FPS.

VideoDD.exe Core i7 4820K GTX 650 graphics Millions of Pixels Per Second ......... Frames Per Second ..... Resolution bltfast blt_and bltfill bltrect bltfast vsynch bltfast bltfast vid_ram stretch rectngl +vsynch cpu_ram refresh vid_ram cpu_ram 640 480 32 41.4 936.3 371.6 34.1 1027.9 118.5 144.2 3569.0 800 600 32 42.6 1372.3 604.5 27.5 1086.3 60.3 108.4 2382.3 1024 768 32 34.1 1709.0 866.3 45.3 1141.5 60.0 47.2 1510.5 1280 1024 32 34.1 2409.9 1625.2 76.4 1150.1 60.0 27.8 904.0 1600 1200 32 41.7 2740.2 2211.1 112.3 1145.0 60.0 23.5 611.6 80486 S3 VLB 640 480 16 11 3 26 4 37 12 ******************************************************************** Various at Resolution 1920 x 1080 32 bits, Core i7 4820K GTX 650 graphics Benchmark Millions of Pixels Per Second ......... Frames Per Second ..... bltfast blt_and bltfill bltrect bltfast vsynch bltfast bltfast vid_ram stretch rectngl +vsynch cpu_ram refresh vid_ram cpu_ram OneDD 41.3 2556.7 2355.1 121.0 1141.3 60.0 21.0 566.1 VideoDD32 41.8 2555.0 2368.4 121.0 1136.1 60.0 21.2 563.5 VideoDD64 35.6 2513.0 2357.5 121.0 1136.4 60.0 18.1 563.7 AMD 64 Radeon 614.6 3828.5 3793.7 76.4 281.5 60.0 500.1 221.2

Go To Start

Direct3D Benchmark - VideoD3D.exe

VideoD3D Benchmark measures graphics speed in terms of Frames Per Second (FPS) via eight simple and more complex tests used in two earlier D3D benchmarks. The program uses Direct3D Retained Mode. The last four tests represent moving up and down a tunnel with various independent moving objects. The third test provides FPS that represents screen refresh Hz (half or less if the system is very slow). The tests are:

1 - Rotating egg gouraud shading solid - 736 Triangles/Frame
2 - Rotating egg gouraud shading wireframe - 736 Triangles/Frame
3 - Rotating egg gouraud shading wireframe WaitForVerticalBlank
4 - 500 cubes within cubes, gouraud shading wireframe - 6688 Triangles/Frame
5 - Tunnel, plain colours
6 - Tunnel, textured with wrap
7 - Tunnel, textured with wrap and shadow
8 - Tunnel, more changing textures - around 2200 Triangles/Frame

Again this benchmark uses the same procedures as VideoWin, with a front end to set monitor pixel size, in full screen mode, and a back end (OneD3D.exe) that can be run separately, using existing monitor settings. Details and results of many systems are included in direct3d results.htm. Example recent results are shown below, including that at 1920 x 1080 via OneD3D.exe. Note that VSYNCH does not appear to work here. The benchmarks, along with source codes, are included in Windows-Graphics-Benchmarks.zip.

Recent systems execute D3D programs via Hardware Abstraction Layer (HAL), for graphics hardware acceleration. This is generally only available at 16 and 32 bits and requires at least three times the video RAM space that is used by Windows. This was not available on earlier systems, where the slower Ramp software emulation had to be used. Examples of these are shown below, to show how performance was increased by HAL and the difference from later PCs.

The benchmark could not be compiled for 64 bits as support for D3DRM was no longer provided. VideoD3D9_64 and VideoD3D9_32, 64 and 32 bit varieties, have been produced using DirectX 9 functions, where some of the tests can be regarded as the same as in the original version. See below. .

VideoD3D.exe Core i7 4820K GTX 650 graphics ...................... Frames Per Second ...................... Emul Resolution gouraud gouraud gouraud cubes plain texture wrap & multi solid wirefrm vsynch wirefrm colors wrap shadow texture HAL 640 480 32 4306.2 4594.2 408.2 46.4 616.4 510.4 375.6 362.4 HAL 800 600 32 3647.0 3725.4 178.8 38.0 393.4 383.0 284.0 271.2 HAL 1024 768 32 3695.2 3702.8 237.8 45.8 375.0 313.8 272.0 268.6 HAL 1280 1024 32 3834.2 3841.6 175.6 35.8 273.8 264.6 240.0 231.6 HAL 1600 1200 32 4518.6 4456.6 179.0 48.4 278.6 271.4 239.0 241.4 HAL 1920 1080 32 4486.6 4477.6 179.8 46.4 266.4 259.2 200.8 200.2 80486 S3 VLB Ramp 800 600 16 6 5 7 0.5 0.9 0.8 0.7 0.7 Pentium MMX Matrox Mystique Ramp 1024 768 16 35 22 35 1 4 4 3 3 MMX 800 600 16 142 115 75 7 20 15 11 11

Go To Start

OpenGL Benchmarks - VideoGL1.exe, OpenGL32.exe, OpenGL64.exe

VideoGL1 Benchmark measures graphics speed in terms of Frames Per Second (FPS) via eight simple and more complex tests. The first six tests portray moving up and down a tunnel with various independent moving objects. The last two tests, included in the latest version, represent a real application for designing kitchens. The first is in wireframe format, drawn with 23,000 straight lines. The second has colours and textures applied to the surfaces, the textures being obtained from photographs of ceramic tiles. The tests are:

1 - Plain colours tunnel, plain colours 1 egg plus other flyers
2 - Plain colours tunnel, textured egg and other flyers
3 - Plain colours tunnel, plain colours 4 eggs and other flyers
4 - Plain colours tunnel, 4 textured eggs
5 - Textured tunnel walls, 4 textured eggs and other flyers
6 - Textured tunnel all surfaces, 4 textured eggs and other flyers
7 - Wireframe kitchen rotating
8 - Rotating kitchen textured with wall, floor and worktop tiles

VideoGL1 is the last benchmark that has a front end to set monitor pixel size, in full screen mode, and a back end (OneGL1.exe) that can be run separately, using existing monitor settings. There are also later 32 bit and 64 bit compilations. Details and results of many systems are included in opengl results.htm. This highlights early day issues regarding drivers and graphics memory requirements. The benchmarks, along with source codes, are included in Windows-Graphics-Benchmarks.zip.

The old results also include some running at different CPU speeds and others with different graphics cards. In those days, the earlier tests tended to have graphics speed limitations, with considerably reduced performance at higher monitor resolution settings, and CPU speed dependency running the most complex tests. Results on the Core i7 indicate more consistent performance at different resolutions but, as indicated, they are for full screen displays.

Some old results are show below to indicate how performance has improved on more modern PCs.

VideoGL1.exe Core i7 4820K GTX 650 graphics ........................ Frames Per Second ........................ Resolution Single Single Multi Multi More More+ Wire Tiled Plain Texture Plain Texture Texture Texture Kitchen Kitchen 640 480 32 1697.73 871.41 953.49 796.91 787.46 751.82 535.80 152.34 800 600 32 1735.13 1099.36 872.98 1413.94 1356.69 636.32 418.33 156.43 1024 768 32 1660.71 1383.94 1455.71 890.66 853.84 846.24 405.36 156.12 1280 1024 32 1514.68 1202.58 1284.18 1147.67 1067.15 775.33 459.80 156.90 1600 1200 32 1315.21 1054.28 1120.71 986.06 944.22 687.78 546.68 153.63 3 at 1920 1080 32 OneGL1.exe 1243.02 1002.31 1050.53 940.31 904.88 680.67 504.74 153.60 OpenGL32.exe 1171.71 970.00 1022.98 914.40 875.93 649.27 569.64 155.10 OpenGL64.exe 1253.20 1001.58 1048.83 942.29 902.76 696.81 406.99 139.29 Pentium 100 MHz Diamond Srealth 800 600 32 2.3 1.3 2.3 0.87 0.19 0.12 Celeron 900 MHz Voodoo 3 1024 768 32 14.3 12.2 12.6 8.0 3.3 2.6 9.1 2.0

Go To Start

Direct3D9 Benchmarks - VideoD3D9_64, VideoD3D9_32

VideoD3D9_64 and VideoD3D9_32, 64 and 32 bit varieties, have been produced using DirectX 9 functions, where some of the tests can be regarded as the same as in the original version. The tests are:

1 - Rotating Egg Gouraud shading, as VideoD3D Test 1
2 - Rotating Egg Wireframe, WaitForVerticalBlank
3 - Rotating Egg and 500 Cubes Wireframe, as VideoD3D Test 4
4 - Textured Tunnel and Rotating Objects, as VideoD3D Test 8
5 - Plain/Fancy Colours, 26 Objects, different movements/rotations
6 - As Test 5 but textured
7 - As Test 6 but using Pixel Shader 2.0, added colours each frame
8 - As Test 6 but using Vertex Shader 2.0, added movement and colours

The benchmark clearly does not plumb the depths of DirectX 9 but it follows the design goals of the Benchmark Collection of being small size, providing a range of useful performance measurements. Unlike VideoD3D, the new program only attempts to run using HAL graphics hardware acceleration. It might not run on an old graphics card even though DirectX 9 is installed. It also performs badly on not too old adapters, as shown in the more detailed results in my direct3d report. Tests 7 and 8 are not attempted if Pixel and Vertex Shader 2.0 are not available. The benchmark uses d3dx9_26.dll and this may have to be downloaded. The benchmarks, along with source codes, are included in Windows-Graphics-Benchmarks.zip.

The benchmark was initially run on the Core i7 based PC using Windows 8. As in the example below, performance of 32 bit and 64 bit compilations were virtually the same. Now, under Windows 10, performance is much slower and the 64 bit version is faster than the one produced for 32 bit operation. Results from an Atom CPU based tablet are also shown, where some speeds are equivalent to those from the powerful desktop PC. Googling reveals lots of complaints about slow graphics performance under Windows 10.

Unlike the earlier benchmarks, this one in run via commands in a BAT file (or a Command Prompt window), where resolution settings are for real pixel dimensions in a window. This also enables testing of the display spead over more than one monitor. The above direct3d report includes some results at 4880 x 1024 pixels, over three monitors. There were some faster results than in the current situation.

VideoD3D9_32 Core i7 4820K GTX 650 graphics, Windows 10 ..................... Frames Per Second ...................... Resolution Shaded WireEgg 500 Texture Colour Texture Pixel Vertex Egg Vsync Cubes Tunnel Objects Objects Shader2 Shader2 640 480 32 802.5 60.0 107.9 589.8 153.7 173.8 169.3 150.3 800 600 32 770.9 60.0 109.2 609.4 158.0 175.6 174.4 152.0 1024 768 32 799.5 60.0 108.9 614.8 158.8 176.5 175.8 153.8 1280 1024 32 828.0 60.0 109.0 606.7 155.3 174.1 174.3 152.7 1920 1080 32 843.3 60.0 113.3 617.0 159.5 176.6 175.7 151.8 Windows 8 1920 1080 32 2748.7 60.0 393.6 1121.0 1460.1 994.3 1053.4 1297.6 VideoD3D9_64 Core i7 4820K GTX 650 graphics, Windows 10 ..................... Frames Per Second ...................... Resolution Shaded WireEgg 500 Texture Colour Texture Pixel Vertex Egg Vsync Cubes Tunnel Objects Objects Shader2 Shader2 640 480 32 1319.0 60.0 179.5 900.5 250.1 275.8 266.8 237.3 800 600 32 1273.3 60.0 177.9 873.8 241.5 264.4 262.2 234.8 1024 768 32 1315.4 60.0 179.3 900.3 243.1 268.2 266.4 238.2 1280 1024 32 1273.8 60.0 178.1 876.1 241.0 264.5 262.7 233.8 1920 1080 32 1242.7 60.0 176.9 855.9 246.8 275.8 274.7 243.9 Windows 8 1920 1080 32 2756.7 60.0 393.5 1121.1 1443.4 1005.0 1002.2 1332.0 Tablet Atom Z8300 Intel HD Graphics, Windows 10 1024 768 32 258.1 60.0 25.8 152.1 175.6 127.0 123.9 151.7

Go To Start

BMPSpeed Benchmarks - BMPSpd.exe, BMPSpeed32.exe, BMPSpeed64.exe

BMPSpeed Benchmark generates BMP files up to 512 MB. It measures speed of saving, loading, scrolling, rotating and editing of 0.5, 1, 2, 4 etc. MB files upwards. The tests carried out are:

1 - Enlarge with blur editing (copy with add/divide instructions) and display.
2 - Save enlargement to disk.
3 - Load from disk, format and display.
4 - Copy from memory scrolling.
5 - Make an extra copy rotating 90 degrees and display.

For further details and results see bmpspeed results.htm and 64 bit graphics tests.htm. These cover all sorts of issues encountered, mainly with main and graphics memory allocation, and whether fast BitBlt copying is used or pixel moving functions. The simple explanation is that, firstly, file sizes used by the software are 32 bits, compared with 24 for BMP files, 512 MB images requiring 682 MB. Secondly, twice this space is required for copying in the rotation test. Then there are other overheads and space for the previous image. There is a buffer in main memory, where allocated space has to be sequential, but might not be with all the chopping and changing, leading to exceptionally slow performance due to disk based paging activities. The benchmarks, along with source codes, are included in Windows-Graphics-Benchmarks.zip.

Below are results on the Core i7 based PC, via Windows 10, where disk drive speeds are clearly greater than 100 MB/second for larger files. Speeds via the newer 32 bit and 64 bit compilations are quite similar, with the latter slightly faster. The original benchmark appears to be slightly slower, using the larger images. See the next page for further comment.

BMPSpd.exe Core i7 4820K GTX 650 graphics, Windows 10 Input Enlarge Save Load Scroll Scroll Rotate Use Image Display Display /Repeat Overall 90 deg Fast Mbytes Secs Secs Secs msecs MB/Sec Secs BitBlt 0.5 0.04 0.02 0.02 0.2 3507.8 0.04 3 1.0 0.08 0.01 0.02 0.3 3819.4 0.04 3 2.0 0.09 0.01 0.05 0.7 4029.7 0.06 3 4.0 0.11 0.05 0.05 1.2 4060.6 0.09 3 8.0 0.14 0.10 0.13 1.6 4251.9 0.13 3 16.0 0.19 0.14 0.21 1.9 4112.6 0.21 3 32.0 0.28 0.35 0.35 2.0 4031.4 0.37 3 64.0 0.38 0.55 0.68 2.0 4053.6 0.63 3 128.0 0.62 1.08 1.33 1.9 4130.1 1.15 3 256.0 1.03 2.22 2.39 1.9 4189.8 2.11 3 512.0 1.32 4.39 4.85 1.9 4141.0 3.38 1 BMPSpeed32.exe Core i7 4820K GTX 650 graphics, Windows 10 Input Enlarge Save Load Scroll Scroll Rotate Use Image Display Display /Repeat Overall 90 deg Fast Mbytes Secs Secs Secs msecs MB/Sec Secs BitBlt 0.5 0.04 0.01 0.02 0.2 3550.9 0.03 3 1.0 0.08 0.01 0.02 0.4 3787.0 0.04 3 2.0 0.09 0.01 0.03 0.7 3757.4 0.05 3 4.0 0.10 0.06 0.05 1.1 4227.3 0.08 3 8.0 0.13 0.09 0.13 1.7 4099.2 0.11 3 16.0 0.16 0.15 0.20 2.0 4028.0 0.17 3 32.0 0.23 0.28 0.39 1.9 4140.7 0.28 3 64.0 0.35 0.58 0.74 2.0 4053.5 0.48 3 128.0 0.55 1.07 1.17 1.9 4198.5 0.85 3 256.0 0.90 2.28 2.52 2.0 4069.0 1.65 3 512.0 1.60 4.38 4.96 2.0 4067.9 2.92 3 BMPSpeed64.exe Core i7 4820K GTX 650 graphics, Older Windows 10 Input Enlarge Save Load Scroll Scroll Rotate Use Image Display Display /Repeat Overall 90 deg Fast Mbytes Secs Secs Secs msecs MB/Sec Secs BitBlt 0.5 0.05 0.01 0.04 0.2 3648.3 0.03 3 1.0 0.07 0.01 0.02 0.4 3787.2 0.04 3 2.0 0.08 0.01 0.02 0.8 3523.5 0.05 3 4.0 0.10 0.04 0.05 1.1 4165.9 0.07 3 8.0 0.14 0.08 0.13 1.7 4073.3 0.10 3 16.0 0.15 0.15 0.24 1.9 4131.0 0.15 3 32.0 0.20 0.26 0.39 1.9 4155.2 0.26 3 64.0 0.31 0.58 0.68 2.0 3991.1 0.44 3 128.0 0.49 1.06 1.36 2.0 3971.3 0.83 3 256.0 0.76 2.10 2.50 1.9 4098.1 1.61 3 512.0 1.30 4.30 4.84 1.9 4101.7 2.91 3

See Comparisons in next page

BMPSpeed Comparisons and Memory Use

Below are comparisons, including Windows 10 versus Windows 8 and reported memory use, recorded in the benchmark log files .

The Window 10 last BMPSpd test was indicated as not using fast BitBlt copying, but some tests were faster than expected, compared with 256 MB results, but reported memory size was lower.

Window 8 performance is shown to be slightly faster than that via Windows 10. Memory statistics indicate significant occupancy of the paging file and apparent memory use (larger percentage of significantly more megabytes).

Perhaps someone might be able to interpret these details.

Input Enlarge Save Load Scroll Scroll Rotate Use Image Display Display /Repeat Overall 90 deg Fast Mbytes Secs Secs Secs msecs MB/Sec Secs BitBlt BMPSpd Windows 10 256.0 1.03 2.22 2.39 1.9 4189.8 2.11 3 512.0 1.32 4.39 4.85 1.9 4141.0 3.38 1 BMPSpd Windows 8 256.0 0.87 2.22 2.26 1.4 5861.2 1.96 3 512.0 1.57 4.11 4.52 1.4 5853.2 3.64 3 BMPSpeed64 Windows 10 256.0 0.76 2.10 2.50 1.9 4098.1 1.61 3 512.0 1.30 4.30 4.84 1.9 4101.7 2.91 3 BMPSpeed64 Windows 8 256.0 0.64 2.08 2.31 1.3 5904.1 1.48 3 512.0 1.12 4.45 4.62 1.4 5892.0 2.65 3 Memory Status Maximum Use BMPSpd Win8 32 Bit 64 Bit Mbytes of physical memory 2047 4095 32704 32704 Percent of memory in use 11 11 14 14 Free physical memory Mbytes 2047 4095 28061 28109 Mbytes of paging file 4095 4095 37568 37568 Free Mbytes of paging file 4095 4095 32949 33012 User Mbytes of virtual space 2047 2047 4095 134217727 Free user virtual Mbytes 905 930 2954 134216578

Go To Start

JavaDraw Benchmark - javaDrawPC.class

This all Java benchmark uses small to rather excessive simple objects to measure Frames Per Second (FPS) drawing performance,. The test functions are:

1 - Load two PNG files, one bitmap moving left/right for each frame, the other rotating.
2 - Repeat test 1, avoiding startup overheads.
3 - Add 2 SweepGradient multi-coloured circles, from a file, moving side to centre and back.
4 - Add 200 random drawn small circles in the middle of the screen.
5 - Add 80 lines drawn from the centre of each side to the opposite side, with changing colours.
6 - Add 4000 random drawn small circles, filling the screen.

These benchmarks, including source codes, are available in Windows-Graphics-Benchmarks.zip, to run via Windows or Linux. Details and results can be found in JavaDraw.htm, with further information in general ResearchGate reports on Raspberry Pi and Android benchmarks.

The first version of this benchmark did not repeat test 1 and that produced some slow speeds. The next version produced unacceptable slow performance on a Core i7 based PC, running Windows 8. This was affected by the Javax Swing timer apparently misbehaving. The latest version uses Abstract Window Toolkit {AWT) functions, that seem to behave properly. However, some significant differences were produced using alternative Java packages. Details of these complications are included in JavaDraw.htm. This includes some results from using javac 1.6, 1.8 and 1.8, running under JRE 1.6, 1.7 and 1.8. The results below are from running the supplied javaDrawPC program on the same PC, via Windows and Linux, and showing some significant performance variations.

Online Versions - are included in Windows-Graphics-Benchmarks.zip. These can be used from a remote Internet site, or from a local disk, via supplied HTML files that load the application Applet. Installation of an appropriate Java Run Time Environment is required, where access permissions can be set. See JavaDraw.htm.

************************************************** Core i7 4820K GTX 650 graphics, Windows 10 Java Drawing Benchmark, Nov 16 2017, 12:01:29 Produced by javac 1.6.0_27 Test Frames FPS Display PNG Bitmap Twice Pass 1 8434 842.14 Display PNG Bitmap Twice Pass 2 9145 914.41 Plus 2 SweepGradient Circles 9076 906.69 Plus 200 Random Small Circles 5101 509.59 Plus 320 Long Lines 5030 502.75 Plus 4000 Random Small Circles 543 54.21 Total Elapsed Time 60.1 seconds Operating System Windows 10, Arch. x86, Version 10.0 Java Vendor Oracle Corporation, Version 1.8.0_144 Intel64 Family 6 Model 62 Stepping 4, GenuineIntel, 8 CPUs ************************************************** Core i7 4820K GTX 650 graphics, Linux Ubuntu 14.04 Java Drawing Benchmark, Nov 17 2017, 11:31:48 Produced by javac 1.6.0_27 Test Frames FPS Display PNG Bitmap Twice Pass 1 11734 1173.28 Display PNG Bitmap Twice Pass 2 18368 1836.62 Plus 2 SweepGradient Circles 13152 1315.07 Plus 200 Random Small Circles 8040 803.92 Plus 320 Long Lines 3230 322.94 Plus 4000 Random Small Circles 678 67.77 Total Elapsed Time 60.0 seconds Operating System Linux, Arch. amd64, Version 3.13.0-43-generic Java Vendor Oracle Corporation, Version 1.8.0_111 null, null CPUs

Go To Start

Linux OpenGL Benchmarks - videogl32, videogl64

This benchmark uses the same basic OpenGL source code as the Windows OpenGL Benchmarks with description and results provided in linux opengl benchmarks.htm. Videogl32 and videogl64 are 32-Bit and 64-Bit Linux compilations that can be found in linux-graphics-benchmarks.tar.gz, along with source code, BMP files, compilation and running instructions. The benchmarks measure graphics speed in terms of Frames Per Second (FPS) via six simple and more complex tests. The first four tests portray moving up and down a tunnel including various independently moving objects, with and without texturing. The last two tests, represent a real application for designing kitchens. The first is in wireframe format, drawn with 23,000 straight lines. The second has colours and textures applied to the surfaces. The tests are:

1 - Plain colours tunnel, plain colours 1 egg plus other flyers
2 - Plain colours tunnel, plain colours 4 eggs and other flyers
3 - Textured tunnel walls, textured egg and other flyers
4 - Textured tunnel all surfaces, 4 textured eggs and other flyers
5 - Wireframe kitchen rotating
6 - Rotating kitchen textured with wall, floor and worktop tiles

A difference from the Windows version textured kitchen, is the the outside scene can be seen thorough the windows. Another is that run time parameters can be set to execute the programs in different window sizes, using a script file to produce a tabular results log file.

Below are results from running the benchmarks on the Core i7 based PC. The 64 bit results were produced via the main 64 bit Ubuntu 14.04 Operating System, demonstrating faster performance than the Windows versions. Using 64 bit Linux, there are complication in installing 32 bit libraries and attempts were abandoned on this PC. The PC was booted with 32 bit Ubuntu 14.04 from a USB flash drive, to produce the 32 bit results shown below. This identified another complication, that is the difficulties in turning off vsync, which normally reduces FPS to 60 or less, as with this case. The 32 bit Ubuntu system did not have a GeForce driver installed, leading to the poor measured performance (but, at least the benchmark ran).

Note, approval was given to Canonical to include this benchmark in the testing framework for the Unity desktop.

Core i7 4820K GTX 650 graphics, Linux Ubuntu 14.04 Linux OpenGL Benchmark 64 Bit Version 1, Sat Nov 18 17:05:00 2017 Window Size Coloured Objects Textured Objects WireFrm Texture Pixels Few All Few All Kitchen Kitchen Wide High FPS FPS FPS FPS FPS FPS 320 240 9851.3 5804.6 1978.9 1174.8 687.3 387.2 640 480 6555.2 5617.1 2231.1 1248.4 720.1 372.4 1024 768 3242.6 3058.5 1917.7 1250.9 721.4 368.0 1280 1024 2230.4 2109.1 1491.4 1172.4 762.0 363.4 1600 1200 1797.3 1753.1 1313.8 1065.0 769.7 363.4 1920 1080 1593.3 1534.1 1217.9 990.6 781.7 371.8 ##################################################################### Core i7 4820K GTX 650 graphics, 32 Bit Linux Ubuntu 14.04 Linux OpenGL Benchmark 32 Bit Version 1, Sun Nov 19 17:32:54 2017 Window Size Coloured Objects Textured Objects WireFrm Texture Pixels Few All Few All Kitchen Kitchen Wide High FPS FPS FPS FPS FPS FPS 320 240 64.0 52.0 38.7 33.8 32.4 31.4 640 480 65.8 50.3 39.3 33.6 33.2 31.2 1024 768 64.2 50.3 36.6 33.7 33.4 31.2 1920 1080 60.6 45.0 32.4 30.6 30.0 29.6

Go To Start

Linux - SDL_bmpspd32, SDL_bmpspd64

SDL_bmpspd32 and SDL_bmpspd64 benchmarks execute the same test functions as Windows BMPSpeed Benchmarks. They are 32 bit and 64 bit varieties compiled to run under Linux using Simple DirectMedia Layer (SDL) functions. The benchmarks generate BMP files and measure speed of saving, loading, scrolling, rotating and editing of 0.5, 1, 2, 4 etc. to 512 MB images. Details and results are included in linux image processing benchmarks.htm. The benchmarks and source code can be downloaded in linux-graphics-benchmarks.tar.gz. The tests run are as follows:

The PC used for the 64 bit benchmark demonstrated reading and writing speeds of more than 100 MB/second, using a disk drive. Of the other tests, some were faster and some slower than the Windows benchmark. As shown in the results below, this version also includes details of memory used in each test.

Again, 32 bit Ubuntu, with a basic graphics driver, was used for the 32 bit benchmark, loaded via a USB flash drive, resulting in the slow reading and writing speeds.

Core i7 4820K GTX 650 graphics, Linux Ubuntu 14.04 Image Editing Speeds 64 Bit Version 1, Sat Nov 18 17:17:30 2017 Input Enlarge Save Load Scroll Scroll Rotate Max MB Image Display Display Repeat Overall 90 deg Memory Mbytes Secs Secs Secs msecs MB/Sec Secs Used 0.5 0.01 0.28 0.01 0.57 880.87 0.00 926.5 1.0 0.01 0.10 0.01 0.98 1014.83 0.01 928.0 2.0 0.01 0.01 0.02 1.71 1225.72 0.02 931.4 4.0 0.02 0.03 0.03 3.69 1012.45 0.03 938.2 8.0 0.03 0.05 0.19 4.81 1099.48 0.02 951.1 16.0 0.05 0.10 0.27 5.89 1055.81 0.06 975.9 32.0 0.06 0.36 0.38 5.84 1065.57 0.06 1026.9 64.0 0.11 0.53 0.76 5.90 1054.69 0.13 1158.6 128.0 0.20 1.13 1.15 5.98 1040.95 0.23 1272.6 256.0 0.37 2.30 2.51 5.65 1101.36 0.60 1615.9 512.0 0.73 4.63 4.71 5.97 1041.72 0.82 2316.5 ##################################################################### Core i7 4820K GTX 650 graphics, 32 Bit Linux Ubuntu 14.04 Image Editing Speeds 32 Bit Version 1, Sun Nov 19 16:21:49 2017 Input Enlarge Save Load Scroll Scroll Rotate Max MB Image Display Display Repeat Overall 90 deg Memory Mbytes Secs Secs Secs msecs MB/Sec Secs Used 0.5 0.01 0.12 0.08 1.76 284.03 0.02 443.3 1.0 0.03 0.84 0.18 3.54 282.39 0.01 447.5 2.0 0.02 0.88 1.57 5.96 352.15 0.03 451.5 4.0 0.03 2.18 1.22 9.28 402.08 0.02 439.2 8.0 0.03 1.98 3.21 12.67 417.31 0.05 461.3 16.0 0.05 2.38 2.03 14.27 435.91 0.07 485.6 32.0 0.07 3.54 2.52 16.29 381.83 0.09 523.6 64.0 0.10 7.72 2.28 15.81 393.39 0.14 614.6 128.0 0.19 11.78 4.53 16.56 375.59 0.25 791.1 256.0 0.34 24.84 10.33 17.74 350.60 0.56 1140.7 512.0 0.65 54.50 18.58 17.80 349.44 0.96 1843.4

Go To Start